
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
	<title>YUI Library Examples: Test: Array Processing</title>
    <meta http-equiv="content-type" content="text/html; charset=utf-8">
    	<link rel="stylesheet" type="text/css" href="../../assets/yui.css" >

<style>
    /*Supplemental CSS for the YUI distribution*/
    #custom-doc { width: 95%; min-width: 950px; }
    #pagetitle {background-image: url(../../assets/bg_hd.gif);}
/*    #pagetitle h1 {background-image: url(../../assets/title_h_bg.gif);}*/
</style>

<link rel="stylesheet" type="text/css" href="../../assets/dpSyntaxHighlighter.css">
<link type="text/css" rel="stylesheet" href="../../build/cssfonts/fonts-min.css" />
<script type="text/javascript" src="../../build/yui/yui-min.js"></script>
<style type="text/css">
#testLogger {
    margin-bottom: 1em;
}

#testLogger .yui3-console .yui3-console-title {
    border: 0 none;
    color: #000;
    font-size: 13px;
    font-weight: bold;
    margin: 0;
    text-transform: none;
}
#testLogger .yui3-console .yui3-console-entry-meta {
    margin: 0;
}

.yui3-skin-sam .yui3-console-entry-pass .yui3-console-entry-cat {
    background: #070;
    color: #fff;
}
</style>

</head>
<body id="yahoo-com" class="yui3-skin-sam  yui-skin-sam">
<div id="custom-doc" class="yui-t2">
<div id="hd">
	<div id="ygunav">
		<p>
            <em>
                <a href="http://developer.yahoo.com/yui/3/">YUI 3.x Home</a> <i> - </i>	
            </em>
		</p>
		<form action="http://search.yahoo.com/search" id="sitesearchform">
            <input name="vs" type="hidden" value="developer.yahoo.com">
            <input name="vs" type="hidden" value="yuiblog.com">
		    <div id="sitesearch">
		    	<label for="searchinput">Site Search (YDN &amp; YUIBlog): </label>
			    <input type="text" id="searchinput" name="p">
			    <input type="submit" value="Search" id="searchsubmit" class="ygbt">
		    </div>
		</form>
    </div>
	<div id="ygma"><a href="../../"><img src="../../assets/logo.gif"  border="0" width="200" height="93"></a></div>
	<div id="pagetitle"><h1>YUI Library Examples: Test: Array Processing</h1></div>
</div>
<div id="bd">


	<div id="yui-main">
		<div class="yui-b">
		  <div class="yui-ge">
			  <div class="yui-u first example" id="main">

	<h2>Test: Array Processing</h2>

	<div id="example" class="promo">
	<div class="example-intro">
	<p>This example shows how to use the <a href="/yui/test/#arrayassert"><code>ArrayAssert</code></a> object, which
  contains assertions designed to be used specifically with JavaScript Arrays and array-like objects.</p>	</div>	

	<div class="module example-container ">
			<div class="hd exampleHd">
			<p class="newWindowButton yui-skin-sam">
                <a href="test-array-tests_clean.html" target="_blank">View example in new window.</a>
            </p>
		</div>		<div id="example-canvas" class="bd">

		
	<!--BEGIN SOURCE CODE FOR EXAMPLE =============================== -->
	
	<div id="testLogger"></div>
<script type="text/javascript">
YUI().use("node", "console", "test",function (Y) {

    Y.namespace("example.test");
    
    Y.example.test.ArrayTestCase = new Y.Test.Case({

        //the name of the test case - if not provided, one is automatically generated
        name: "Array Tests",
        
        //-------------------------------------------------------------------------
        // Setup and teardown
        //-------------------------------------------------------------------------
    
        /*
         * The setUp() method is used to setup data that necessary for a test to
         * run. This method is called immediately before each test method is run,
         * so it is run as many times as there are test methods.
         */
        setUp : function () {        
            this.data = new Array (0,1,2,3,4,5);        
        },
        
        /*
         * The tearDown() method is used to clean up the initialization that was done
         * in the setUp() method. Ideally, it should free up all memory allocated in
         * setUp(), anticipating any possible changes to the data. This method is called
         * immediately after each test method is run.
         */
        tearDown : function () {
            delete this.data;
        },
        
        //-------------------------------------------------------------------------
        // Basic tests - all method names must begin with "test"
        //-------------------------------------------------------------------------
        
        /*
         * Test the push() method.
         */
        testPush : function() {
        
            //shortcut variables
            var ArrayAssert = Y.ArrayAssert;
        
            //do whatever data manipulation is necessary
            this.data.push(6);
        
            //array-specific assertions
            ArrayAssert.isNotEmpty(this.data, "Array should not be empty.");
            ArrayAssert.contains(6, this.data, "Array should contain 6.");
            ArrayAssert.indexOf(6, this.data, 6, "The value in position 6 should be 6.");
            
            //check that all the values are there
            ArrayAssert.itemsAreEqual([0,1,2,3,4,5,6], this.data, "Arrays should be equal.");        
            
        },
        
        /*
         * Test the pop() method.
         */
        testPop : function() {
        
            //shortcut variables
            var Assert = Y.Assert;
            var ArrayAssert = Y.ArrayAssert;
        
            //do whatever data manipulation is necessary
            var value = this.data.pop();
            
            //array shouldn't be empty
            ArrayAssert.isNotEmpty(this.data, "Array should not be empty.");                
        
            //basic equality assertion - expected value, actual value, optional error message
            Assert.areEqual(5, this.data.length, "Array should have 5 items.");
            Assert.areEqual(5, value, "Value should be 5.");   
            
            ArrayAssert.itemsAreSame([0,1,2,3,4], this.data, "Arrays should be equal.");                                
        },
        
        /*
         * Test the reverse() method.
         */
        testReverse : function() {
        
            //shortcut variables
            var ArrayAssert = Y.ArrayAssert;
        
            //do whatever data manipulation is necessary
            this.data = this.data.reverse();
            
            ArrayAssert.itemsAreEqual([5,4,3,2,1,0], this.data, "Arrays should be equal.");                              
        },
        
        /*
         * Test the shift() method.
         */
        testShift : function() {
        
            //shortcut variables
            var Assert = Y.Assert;
            var ArrayAssert = Y.ArrayAssert;
        
            //do whatever data manipulation is necessary
            var value = this.data.shift();
        
            //array shouldn't be empty
            ArrayAssert.isNotEmpty(this.data, "Array should not be empty.");                
        
            //basic equality assertion - expected value, actual value, optional error message
            Assert.areEqual(5, this.data.length, "Array should have 6 items."); 
            Assert.areEqual(0, value, "Value should be 0."); 
            
            ArrayAssert.itemsAreEqual([1,2,3,4,5], this.data, "Arrays should be equal.");                              
        },            
        
        /*
         * Test the splice() method.
         */
        testSplice : function() {
        
            //shortcut variables
            var Assert = Y.Assert;
            var ArrayAssert = Y.ArrayAssert;
        
            //do whatever data manipulation is necessary
            var removed = this.data.splice(1, 2, 99, 100);
        
            //basic equality assertion - expected value, actual value, optional error message
            Assert.areEqual(6, this.data.length, "Array should have 6 items.");              
        
            //the new items should be there
            ArrayAssert.indexOf(99, this.data, 1, "Value at index 1 should be 99.");   
            ArrayAssert.indexOf(100, this.data, 2, "Value at index 2 should be 100.");   
            
            ArrayAssert.itemsAreEqual([0,99,100,3,4,5], this.data, "Arrays should be equal.");  
            ArrayAssert.itemsAreEqual([1,2], removed, "Removed values should be an array containing 1 and 2.");

        },

        /*
         * Test the unshift() method.
         */
        testUnshift : function() {
        
            //shortcut variables
            var Assert = Y.Assert;
            var ArrayAssert = Y.ArrayAssert;
        
            //do whatever data manipulation is necessary
            this.data.unshift(-1);
        
            //basic equality assertion - expected value, actual value, optional error message
            Assert.areEqual(7, this.data.length, "Array should have 7 items."); 

            //the new item should be there
            ArrayAssert.indexOf(-1, this.data, 0, "First item should be -1."); 
        
            ArrayAssert.itemsAreEqual([-1,0,1,2,3,4,5], this.data, "Arrays should be equal.");                              
        } 
        
    });
     
    //create the console
    var r = new Y.Console({
        newestOnTop : false,
        style: 'block' // to anchor in the example content
    });
    
    r.render('#testLogger');
    
    Y.Test.Runner.add(Y.example.test.ArrayTestCase);

    //run the tests
    Y.Test.Runner.run();
});

</script>
	
	<!--END SOURCE CODE FOR EXAMPLE =============================== -->
	
		
		</div>
	</div>			
	</div>
		
	<h2 class="first">Array Assertions</h2>

<p>This example uses the <code>Y.ArrayAssert</code> object to test methods on JavaScript's
  built-in <code>Array</code> object. The intent of this example is to introduce <code>Y.ArrayAssert</code> and its methods
  as an alternative to the generic methods available on <code>Y.Assert</code>.</p>
<p>The example begins by creating an example namespace and <code>Y.Test.Case</code>:</p>
<div id="syntax-16d5ee1f2924ee70bb3af3b9a09b808b" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1">Y.<span class="kw2">namespace</span><span class="br0">&#40;</span><span class="st0">&quot;example.test&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="kw3">name</span><span class="sy0">:</span> <span class="st0">&quot;Array Tests&quot;</span><span class="sy0">,</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="co1">//-------------------------------------------------------------------------</span></div></li><li class="li1"><div class="de1">    <span class="co1">// Setup and teardown</span></div></li><li class="li1"><div class="de1">    <span class="co1">//-------------------------------------------------------------------------</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="coMULTI">/*</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    * The setUp() method is used to setup data that necessary for a test to</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    * run. This method is called immediately before each test method is run,</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    * so it is run as many times as there are test methods.</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    */</span></div></li><li class="li2"><div class="de2">    setUp <span class="sy0">:</span> <span class="kw2">function</span> <span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">        <span class="kw1">this</span>.<span class="me1">data</span> <span class="sy0">=</span> <span class="kw2">new</span> Array <span class="br0">&#40;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="coMULTI">/*</span></div></li><li class="li2"><div class="de2"><span class="coMULTI">&nbsp;    * The tearDown() method is used to clean up the initialization that was done</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    * in the setUp() method. Ideally, it should free up all memory allocated in</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    * setUp(), anticipating any possible changes to the data. This method is called</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    * immediately after each test method is run.</span></div></li><li class="li1"><div class="de1"><span class="coMULTI">&nbsp;    */</span></div></li><li class="li2"><div class="de2">    tearDown <span class="sy0">:</span> <span class="kw2">function</span> <span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">        <span class="kw1">delete</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li2"><div class="de2"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;">Y.<span class="kw2">namespace</span><span class="br0">&#40;</span><span class="st0">&quot;example.test&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
&nbsp;
    <span class="kw3">name</span><span class="sy0">:</span> <span class="st0">&quot;Array Tests&quot;</span><span class="sy0">,</span>
&nbsp;
    <span class="co1">//-------------------------------------------------------------------------</span>
    <span class="co1">// Setup and teardown</span>
    <span class="co1">//-------------------------------------------------------------------------</span>
&nbsp;
    <span class="coMULTI">/*
     * The setUp() method is used to setup data that necessary for a test to
     * run. This method is called immediately before each test method is run,
     * so it is run as many times as there are test methods.
     */</span>
    setUp <span class="sy0">:</span> <span class="kw2">function</span> <span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
        <span class="kw1">this</span>.<span class="me1">data</span> <span class="sy0">=</span> <span class="kw2">new</span> Array <span class="br0">&#40;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#41;</span><span class="sy0">;</span>
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    <span class="coMULTI">/*
     * The tearDown() method is used to clean up the initialization that was done
     * in the setUp() method. Ideally, it should free up all memory allocated in
     * setUp(), anticipating any possible changes to the data. This method is called
     * immediately after each test method is run.
     */</span>
    tearDown <span class="sy0">:</span> <span class="kw2">function</span> <span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
        <span class="kw1">delete</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">;</span>
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    ...
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-16d5ee1f2924ee70bb3af3b9a09b808b-plain">Y.namespace("example.test");
Y.example.test.ArrayTestCase = new Y.Test.Case({

    name: "Array Tests",

    //-------------------------------------------------------------------------
    // Setup and teardown
    //-------------------------------------------------------------------------

    /*
     * The setUp() method is used to setup data that necessary for a test to
     * run. This method is called immediately before each test method is run,
     * so it is run as many times as there are test methods.
     */
    setUp : function () {
        this.data = new Array (0,1,2,3,4,5);
    },

    /*
     * The tearDown() method is used to clean up the initialization that was done
     * in the setUp() method. Ideally, it should free up all memory allocated in
     * setUp(), anticipating any possible changes to the data. This method is called
     * immediately after each test method is run.
     */
    tearDown : function () {
        delete this.data;
    },

    ...
});</textarea></div><p>This <code>TestCase</code> has a <code>setUp()</code> method that creates an array for all the tests to use, as well as
  a <code>tearDown()</code> method that deletes the array after each test has been executed. This array is used throughout
  the tests as a base for array manipulations.</p>

<h3>Testing <code>push()</code></h3>
<p>The first test is <code>testPush()</code>, which tests the functionality of the <code>Array</code> object's <code>push()</code> method
  (other methods hidden for simpicity):</p>

<div id="syntax-0b139e9ec528a9a73a1d60356a1b417b" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="me1">testPush</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//shortcut variables</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">        <span class="co1">//do whatever data manipulation is necessary</span></div></li><li class="li1"><div class="de1">        <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">push</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//array-specific assertions</span></div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">isNotEmpty</span><span class="br0">&#40;</span><span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should not be empty.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">        ArrayAssert.<span class="me1">contains</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should contain 6.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">6</span><span class="sy0">,</span> <span class="st0">&quot;The value in position 6 should be 6.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//check that all the values are there</span></div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="sy0">,</span><span class="nu0">6</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
&nbsp;
    ...
&nbsp;
    <span class="me1">testPush</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
&nbsp;
        <span class="co1">//shortcut variables</span>
        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//do whatever data manipulation is necessary</span>
        <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">push</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//array-specific assertions</span>
        ArrayAssert.<span class="me1">isNotEmpty</span><span class="br0">&#40;</span><span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should not be empty.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
        ArrayAssert.<span class="me1">contains</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should contain 6.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">6</span><span class="sy0">,</span> <span class="st0">&quot;The value in position 6 should be 6.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//check that all the values are there</span>
        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="sy0">,</span><span class="nu0">6</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    ...
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-0b139e9ec528a9a73a1d60356a1b417b-plain">Y.example.test.ArrayTestCase = new Y.Test.Case({

    ...

    testPush : function() {

        //shortcut variables
        var ArrayAssert = Y.ArrayAssert;

        //do whatever data manipulation is necessary
        this.data.push(6);

        //array-specific assertions
        ArrayAssert.isNotEmpty(this.data, "Array should not be empty.");
        ArrayAssert.contains(6, this.data, "Array should contain 6.");
        ArrayAssert.indexOf(6, this.data, 6, "The value in position 6 should be 6.");

        //check that all the values are there
        ArrayAssert.itemsAreEqual([0,1,2,3,4,5,6], this.data, "Arrays should be equal.");

    },

    ...
});</textarea></div><p>The test begins by setting up a shortcut variables for <code>Y.ArrayAssert</code>, then pushes the value 6 onto
  the <code>data</code> array (which was created by <code>setUp()</code>). Next, <code>Y.ArrayAssert.isNotEmpty()</code> determines if the
  array has at least one item; this should definitely pass because the <code>push()</code> operation only adds values to the array. To determine
  that the new value, 6, is in the array, <code>Y.ArrayAssert.contains()</code> is used. The first argument is the value to look for and the second
  is the array to look in. To find out if the new value ended up where it should have (the last position, index 6), <code>Y.ArrayAssert.indexOf()</code>
  is used, passing in the value to search for as the first argument, the array to search in as the second, and the index at which the value should
  occur as the final argument. Since 6 was pushed onto the end of an array that already had 6 items, it should end up at index 6 (the length of the
  array minus one). As a final test, <code>Y.ArrayAssert.itemsAreEqual()</code> is used to determine that all of the items in the array are in the
  correct place. The first argument of this method is an array that has all of the values that should be in the array you're testing. This assertion
  passes only when the values in both arrays match up (the values are equal and the positions are the same).</p>

<h3>Testing <code>pop()</code></h3>
<p>The next test is <code>testPop()</code>, which tests the functionality of the <code>Array</code> object's <code>pop()</code> method:</p>

<div id="syntax-b4726a49b8274d4b6c7ab9247d1136e2" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="me1">testPop</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//shortcut variables</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//do whatever data manipulation is necessary</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> value <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">pop</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//array shouldn't be empty</span></div></li><li class="li2"><div class="de2">        ArrayAssert.<span class="me1">isNotEmpty</span><span class="br0">&#40;</span><span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should not be empty.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span></div></li><li class="li1"><div class="de1">        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">5</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 5 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">5</span><span class="sy0">,</span> value<span class="sy0">,</span> <span class="st0">&quot;Value should be 5.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">itemsAreSame</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    ...</div></li><li class="li1"><div class="de1"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
&nbsp;
    ...
&nbsp;
    <span class="me1">testPop</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
&nbsp;
        <span class="co1">//shortcut variables</span>
        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span>
        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//do whatever data manipulation is necessary</span>
        <span class="kw2">var</span> value <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">pop</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//array shouldn't be empty</span>
        ArrayAssert.<span class="me1">isNotEmpty</span><span class="br0">&#40;</span><span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should not be empty.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span>
        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">5</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 5 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">5</span><span class="sy0">,</span> value<span class="sy0">,</span> <span class="st0">&quot;Value should be 5.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        ArrayAssert.<span class="me1">itemsAreSame</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    ...
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-b4726a49b8274d4b6c7ab9247d1136e2-plain">Y.example.test.ArrayTestCase = new Y.Test.Case({

    ...

    testPop : function() {

        //shortcut variables
        var Assert = Y.Assert;
        var ArrayAssert = Y.ArrayAssert;

        //do whatever data manipulation is necessary
        var value = this.data.pop();

        //array shouldn't be empty
        ArrayAssert.isNotEmpty(this.data, "Array should not be empty.");

        //basic equality assertion - expected value, actual value, optional error message
        Assert.areEqual(5, this.data.length, "Array should have 5 items.");
        Assert.areEqual(5, value, "Value should be 5.");

        ArrayAssert.itemsAreSame([0,1,2,3,4], this.data, "Arrays should be equal.");

    },

    ...
});</textarea></div><p>This test also starts out by creating some shortcut variables, for <code>Y.Assert</code> and <code>Y.ArrayAssert</code>. Next, the <code>pop()</code>
  method is called, storing the returned item in <code>value</code>. Since <code>pop()</code> should only remove a single item, <code>Y.ArrayAssert.isNotEmpty()</code>
  is called to ensure that only one item has been removed. After that, <code>Y.Assert.areEqual()</code> is called twice: once to check the
  length of the array and once to confirm the value of the item that was removed from the array (which should be 5). The last assertion uses
  <code>Y.ArrayAssert.itemsAreSame()</code>, which is similar to <code>Y.ArrayAssert.itemsAreEqual()</code> in that it compares values between two
  arrays. The difference is that <code>Y.ArrayAssert.itemsAreSame()</code> uses strict equality (<code>===</code>) to compare values, ensuring that
  no behind-the-scenes type conversions will occur (this makes <code>Y.ArrayAssert.itemsAreSame()</code> more useful for working with arrays of
  objects).</p>

<h3>Testing <code>reverse()</code></h3>
<p>The next test is <code>testReverse()</code>, which tests the functionality of the <code>Array</code> object's <code>reverse()</code> method:</p>

<div id="syntax-2a627d3eb83d3e514a856bd1386239a0" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="me1">testReverse</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//shortcut variables</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">        <span class="co1">//do whatever data manipulation is necessary</span></div></li><li class="li1"><div class="de1">        <span class="kw1">this</span>.<span class="me1">data</span> <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">reverse</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">5</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">0</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
&nbsp;
    ...
&nbsp;
    <span class="me1">testReverse</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
&nbsp;
        <span class="co1">//shortcut variables</span>
        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//do whatever data manipulation is necessary</span>
        <span class="kw1">this</span>.<span class="me1">data</span> <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">reverse</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">5</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">0</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    ...
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-2a627d3eb83d3e514a856bd1386239a0-plain">Y.example.test.ArrayTestCase = new Y.Test.Case({

    ...

    testReverse : function() {

        //shortcut variables
        var ArrayAssert = Y.ArrayAssert;

        //do whatever data manipulation is necessary
        this.data = this.data.reverse();

        ArrayAssert.itemsAreEqual([5,4,3,2,1,0], this.data, "Arrays should be equal.");

    },

    ...
});</textarea></div><p>The <code>testRemove()</code> method is very simple, calling <code>reverse()</code> on the array and then testing the result. Since
  every item in the array has changed, the changes can be tested by calling <code>Y.ArrayAssert.itemsAreEqual()</code> once (instead of
  calling <code>Y.ArrayAssert.indexOf()</code> multiple times). The first argument is an array with all the values in the reverse order
  of the array that was created in <code>setUp()</code>. When compared with the second argument, the newly reversed array, the values in
  each position should be equal.</p>

<h3>Testing <code>shift()</code></h3>
<p>The next test is <code>testShift()</code>, which tests the functionality of the <code>Array</code> object's <code>shift()</code> method:</p>

<div id="syntax-55e22bd4278b1b01567136486df995f7" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="me1">testShift</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//shortcut variables</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//do whatever data manipulation is necessary</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> value <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">shift</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//array shouldn't be empty</span></div></li><li class="li2"><div class="de2">        ArrayAssert.<span class="me1">isNotEmpty</span><span class="br0">&#40;</span><span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should not be empty.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span></div></li><li class="li1"><div class="de1">        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">5</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 6 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">0</span><span class="sy0">,</span> value<span class="sy0">,</span> <span class="st0">&quot;Value should be 0.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    ...</div></li><li class="li1"><div class="de1"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
&nbsp;
    ...
&nbsp;
    <span class="me1">testShift</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
&nbsp;
        <span class="co1">//shortcut variables</span>
        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span>
        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//do whatever data manipulation is necessary</span>
        <span class="kw2">var</span> value <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">shift</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//array shouldn't be empty</span>
        ArrayAssert.<span class="me1">isNotEmpty</span><span class="br0">&#40;</span><span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Array should not be empty.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span>
        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">5</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 6 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">0</span><span class="sy0">,</span> value<span class="sy0">,</span> <span class="st0">&quot;Value should be 0.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    ...
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-55e22bd4278b1b01567136486df995f7-plain">Y.example.test.ArrayTestCase = new Y.Test.Case({

    ...

    testShift : function() {

        //shortcut variables
        var Assert = Y.Assert;
        var ArrayAssert = Y.ArrayAssert;

        //do whatever data manipulation is necessary
        var value = this.data.shift();

        //array shouldn't be empty
        ArrayAssert.isNotEmpty(this.data, "Array should not be empty.");

        //basic equality assertion - expected value, actual value, optional error message
        Assert.areEqual(5, this.data.length, "Array should have 6 items.");
        Assert.areEqual(0, value, "Value should be 0.");

        ArrayAssert.itemsAreEqual([1,2,3,4,5], this.data, "Arrays should be equal.");

    },

    ...
});</textarea></div><p>The <code>shift()</code> method removes the first item in the array and returns it (similar to <code>pop()</code>, which removes the item
  from the end). In the <code>testShift()</code> method, <code>shift()</code> is called and the item is stored in <code>value</code>. To ensure
  that the rest of the array is still there, <code>Y.ArrayAssert.isNotEmpty()</code> is called. After that, <code>Array.areEqual()</code> is
  called twice, once to test the length of the array and once to test the value that was returned from <code>shift()</code> (which should be
  0). As a last test, the entire array is tested using <code>Y.ArrayAssert.itemsAreEqual()</code> to ensure that all of the items have shifted
  into the appropriate positions in the array.</p>

<h3>Testing <code>splice()</code></h3>
<p>The next test is <code>testSplice()</code>, which tests the functionality of the <code>Array</code> object's <code>splice()</code> method:</p>

<div id="syntax-67914c87e3034b4baf12494728a14b22" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="me1">testSplice</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//shortcut variables</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//do whatever data manipulation is necessary</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> removed <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">splice</span><span class="br0">&#40;</span><span class="nu0">1</span><span class="sy0">,</span> <span class="nu0">2</span><span class="sy0">,</span> <span class="nu0">99</span><span class="sy0">,</span> <span class="nu0">100</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span></div></li><li class="li2"><div class="de2">        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 6 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//the new items should be there</span></div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="nu0">99</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">1</span><span class="sy0">,</span> <span class="st0">&quot;Value at index 1 should be 99.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="nu0">100</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">2</span><span class="sy0">,</span> <span class="st0">&quot;Value at index 2 should be 100.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">99</span><span class="sy0">,</span><span class="nu0">100</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="br0">&#93;</span><span class="sy0">,</span> removed<span class="sy0">,</span> <span class="st0">&quot;Removed values should be an array containing 1 and 2.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
&nbsp;
    ...
&nbsp;
    <span class="me1">testSplice</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
&nbsp;
        <span class="co1">//shortcut variables</span>
        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span>
        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//do whatever data manipulation is necessary</span>
        <span class="kw2">var</span> removed <span class="sy0">=</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">splice</span><span class="br0">&#40;</span><span class="nu0">1</span><span class="sy0">,</span> <span class="nu0">2</span><span class="sy0">,</span> <span class="nu0">99</span><span class="sy0">,</span> <span class="nu0">100</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span>
        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">6</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 6 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//the new items should be there</span>
        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="nu0">99</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">1</span><span class="sy0">,</span> <span class="st0">&quot;Value at index 1 should be 99.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="nu0">100</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">2</span><span class="sy0">,</span> <span class="st0">&quot;Value at index 2 should be 100.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">99</span><span class="sy0">,</span><span class="nu0">100</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="br0">&#93;</span><span class="sy0">,</span> removed<span class="sy0">,</span> <span class="st0">&quot;Removed values should be an array containing 1 and 2.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    ...
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-67914c87e3034b4baf12494728a14b22-plain">Y.example.test.ArrayTestCase = new Y.Test.Case({

    ...

    testSplice : function() {

        //shortcut variables
        var Assert = Y.Assert;
        var ArrayAssert = Y.ArrayAssert;

        //do whatever data manipulation is necessary
        var removed = this.data.splice(1, 2, 99, 100);

        //basic equality assertion - expected value, actual value, optional error message
        Assert.areEqual(6, this.data.length, "Array should have 6 items.");

        //the new items should be there
        ArrayAssert.indexOf(99, this.data, 1, "Value at index 1 should be 99.");
        ArrayAssert.indexOf(100, this.data, 2, "Value at index 2 should be 100.");

        ArrayAssert.itemsAreEqual([0,99,100,3,4,5], this.data, "Arrays should be equal.");
        ArrayAssert.itemsAreEqual([1,2], removed, "Removed values should be an array containing 1 and 2.");

    },

    ...
});</textarea></div><p>The <code>splice()</code> method is one of the most powerful <code>Array</code> manipulations. It can both remove and add any number of items
  from an array at the same time. This test begins by splicing some values into the array. When calling <code>splice()</code>, the first argument
  is 1, indicating that values should be inserted at index 1 of the array; the second argument is 2, indicating that two values should be
  removed from the array (the value in index 1 and the value in index 2); the third and fourth arguments are values that should be inserted
  into the array at the position given by the first argument. Essentially, values 1 and 2 should end up being replaced by values 99 and 100 in
  the array.</p>
<p>The first test is to determine that the length of the array is still 6 (since the previous step removed two items and then inserted two, the
  length should still be 6). After that, <code>Y.Assert.indexOf()</code> is called to determine that the values of 99 and 100 are in positions
  1 and 2, respectively. To ensure the integrity of the entire array, <code>Y.ArrayAssert.itemsAreEqual()</code> is called on the array, comparing
  it to an array with the same values. The very last step is to test the value returned from <code>splice()</code>, which is an array containing
  the removed values, 1 and 2. <code>Y.ArrayAssert.itemsAreEqual()</code> is appropriate for this task as well.</p>

<h3>Testing <code>unshift()</code></h3>
<p>The next test is <code>testUnshift()</code>, which tests the functionality of the <code>Array</code> object's <code>unshift()</code> method:</p>

<div id="syntax-cbb0535d1a225b91135536168c614377" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">    <span class="me1">testUnshift</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//shortcut variables</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//do whatever data manipulation is necessary</span></div></li><li class="li1"><div class="de1">        <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">unshift</span><span class="br0">&#40;</span><span class="sy0">-</span><span class="nu0">1</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span></div></li><li class="li2"><div class="de2">        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">7</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 7 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">        <span class="co1">//the new item should be there</span></div></li><li class="li1"><div class="de1">        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="sy0">-</span><span class="nu0">1</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">0</span><span class="sy0">,</span> <span class="st0">&quot;First item should be -1.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li2"><div class="de2">        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="sy0">-</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    <span class="br0">&#125;</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">    ...</div></li><li class="li2"><div class="de2"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;">Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span> <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Test</span>.<span class="kw1">Case</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
&nbsp;
    ...
&nbsp;
    <span class="me1">testUnshift</span> <span class="sy0">:</span> <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span>
&nbsp;
        <span class="co1">//shortcut variables</span>
        <span class="kw2">var</span> Assert <span class="sy0">=</span> Y.<span class="me1">Assert</span><span class="sy0">;</span>
        <span class="kw2">var</span> ArrayAssert <span class="sy0">=</span> Y.<span class="me1">ArrayAssert</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//do whatever data manipulation is necessary</span>
        <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">unshift</span><span class="br0">&#40;</span><span class="sy0">-</span><span class="nu0">1</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//basic equality assertion - expected value, actual value, optional error message</span>
        Assert.<span class="me1">areEqual</span><span class="br0">&#40;</span><span class="nu0">7</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span>.<span class="me1">length</span><span class="sy0">,</span> <span class="st0">&quot;Array should have 7 items.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        <span class="co1">//the new item should be there</span>
        ArrayAssert.<span class="me1">indexOf</span><span class="br0">&#40;</span><span class="sy0">-</span><span class="nu0">1</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="nu0">0</span><span class="sy0">,</span> <span class="st0">&quot;First item should be -1.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
        ArrayAssert.<span class="me1">itemsAreEqual</span><span class="br0">&#40;</span><span class="br0">&#91;</span><span class="sy0">-</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">0</span><span class="sy0">,</span><span class="nu0">1</span><span class="sy0">,</span><span class="nu0">2</span><span class="sy0">,</span><span class="nu0">3</span><span class="sy0">,</span><span class="nu0">4</span><span class="sy0">,</span><span class="nu0">5</span><span class="br0">&#93;</span><span class="sy0">,</span> <span class="kw1">this</span>.<span class="me1">data</span><span class="sy0">,</span> <span class="st0">&quot;Arrays should be equal.&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
    <span class="br0">&#125;</span><span class="sy0">,</span>
&nbsp;
    ...
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-cbb0535d1a225b91135536168c614377-plain">Y.example.test.ArrayTestCase = new Y.Test.Case({

    ...

    testUnshift : function() {

        //shortcut variables
        var Assert = Y.Assert;
        var ArrayAssert = Y.ArrayAssert;

        //do whatever data manipulation is necessary
        this.data.unshift(-1);

        //basic equality assertion - expected value, actual value, optional error message
        Assert.areEqual(7, this.data.length, "Array should have 7 items.");

        //the new item should be there
        ArrayAssert.indexOf(-1, this.data, 0, "First item should be -1.");

        ArrayAssert.itemsAreEqual([-1,0,1,2,3,4,5], this.data, "Arrays should be equal.");

    },

    ...
});</textarea></div><p>Working similar to <code>push()</code>, <code>unshift()</code> adds a value to the array, but the item is added to the front (index 0) instead of
  the back. This test begins by adding the value -1 to the array. The first assertion determines if the length of the array has been incremented
  to 7 to account for the new value. After that, <code>Y.ArrayAssert.indexOf()</code> is used to determine if the value has been placed in the
  correct location. The final assertions tests that the entire array is expected by using <code>Y.ArrayAssert.itemsAreEqual()</code>.</p>

<h3>Running the tests</h3>

<p>With all of the tests defined, the last step is to run them:</p>

<div id="syntax-cacdf5e20ab83125d5eb4bd7e2f6e17a" class="yui-syntax-highlight"><div class="numbers"><pre class="javascript" style="font-family:monospace;"><ol><li class="li1"><div class="de1"><span class="co1">//create the console</span></div></li><li class="li1"><div class="de1"><span class="kw2">var</span> r <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Console</span><span class="br0">&#40;</span><span class="br0">&#123;</span></div></li><li class="li1"><div class="de1">    verbose <span class="sy0">:</span> <span class="kw2">true</span><span class="sy0">,</span></div></li><li class="li1"><div class="de1">    newestOnTop <span class="sy0">:</span> <span class="kw2">false</span></div></li><li class="li2"><div class="de2"><span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">r.<span class="me1">render</span><span class="br0">&#40;</span><span class="st0">'#testLogger'</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li1"><div class="de1">&nbsp;</div></li><li class="li1"><div class="de1">Y.<span class="me1">Test</span>.<span class="me1">Runner</span>.<span class="me1">add</span><span class="br0">&#40;</span>Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li><li class="li2"><div class="de2">&nbsp;</div></li><li class="li1"><div class="de1"><span class="co1">//run the tests</span></div></li><li class="li1"><div class="de1">Y.<span class="me1">Test</span>.<span class="me1">Runner</span>.<span class="me1">run</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span></div></li></ol></pre></div><div class="nonumbers"><pre class="javascript" style="font-family:monospace;"><span class="co1">//create the console</span>
<span class="kw2">var</span> r <span class="sy0">=</span> <span class="kw2">new</span> Y.<span class="me1">Console</span><span class="br0">&#40;</span><span class="br0">&#123;</span>
    verbose <span class="sy0">:</span> <span class="kw2">true</span><span class="sy0">,</span>
    newestOnTop <span class="sy0">:</span> <span class="kw2">false</span>
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
r.<span class="me1">render</span><span class="br0">&#40;</span><span class="st0">'#testLogger'</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
Y.<span class="me1">Test</span>.<span class="me1">Runner</span>.<span class="me1">add</span><span class="br0">&#40;</span>Y.<span class="me1">example</span>.<span class="me1">test</span>.<span class="me1">ArrayTestCase</span><span class="br0">&#41;</span><span class="sy0">;</span>
&nbsp;
<span class="co1">//run the tests</span>
Y.<span class="me1">Test</span>.<span class="me1">Runner</span>.<span class="me1">run</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span></pre></div><textarea id="syntax-cacdf5e20ab83125d5eb4bd7e2f6e17a-plain">//create the console
var r = new Y.Console({
    verbose : true,
    newestOnTop : false
});

r.render('#testLogger');

Y.Test.Runner.add(Y.example.test.ArrayTestCase);

//run the tests
Y.Test.Runner.run();</textarea></div>
<p>Before running the tests, it's necessary to create a <code>Y.Console</code> object to display the results (otherwise the tests would run
  but you wouldn't see the results). After that, the <code>Y.Test.Runner</code> is loaded with the <code>Y.Test.Case</code> object by calling
  <code>add()</code> (any number of <code>Y.Test.Case</code> and <code>TestSuite</code> objects can be added to a <code>Y.Test.Runner</code>,
  this example only adds one for simplicity). The very last step is to call <code>run()</code>, which begins executing the tests in its
  queue and displays the results in the <code>Y.Console</code>.</p>				</div>
				<div class="yui-u sidebar">
					
				
					<div id="examples" class="mod box4">
                        <div class="hd">
						<h4>
    Test Examples:</h4>
                        </div>
						<div class="bd">
							<ul>
								<li><a href='../test/test-simple-example.html'>Simple Testing Example</a></li><li><a href='../test/test-advanced-test-options.html'>Advanced Test Options</a></li><li class='selected'><a href='../test/test-array-tests.html'>Array Processing</a></li><li><a href='../test/test-async-test.html'>Asynchronous Testing</a></li><li><a href='../test/test-async-event-tests.html'>Asynchronous Event Testing</a></li>							</ul>
						</div>
					</div>
					
					<div class="mod box4">
                        <div class="hd">
						<h4>More Test Resources:</h4>
                        </div>
                        <div class="bd">
						<ul>
							<!-- <li><a href="http://developer.yahoo.com/yui/test/">User's Guide</a> (external)</li> -->
<li><a href="../../api/module_test.html">API Documentation</a></li></ul>
                        </div>
					</div>
			  </div>
		</div>
		
		</div>
	</div>


<div class="yui-b toc3" id="tocWrapper">
<!-- TABLE OF CONTENTS -->
<div id="toc">
	
<ul>
<li class="sect first">YUI 3 Resources</li><li class="item"><a title="YUI 3 -- Yahoo! User Interface (YUI) Library" href="http://developer.yahoo.com/yui/3/">YUI 3 Web Site</a></li><li class="item"><a title="Examples of every YUI utility and control in action" href="../../examples/">YUI 3 Examples</a></li><li class="item"><a title="Instantly searchable API documentation for the entire YUI library." href="../../api/">YUI 3 API Docs</a></li><li class="item"><a title="YUI 3 Dependency Configurator -- configure your custom YUI implementation" href="http://developer.yahoo.com/yui/3/configurator/index.html">YUI 3 Dependency Configurator</a></li><li class="item"><a title="The YUI 3 Forum on YUILibrary.com" href="http://yuilibrary.com/forum/viewforum.php?f=15">YUI 3 Forums (external)</a></li><li class="item"><a title="Found a bug or a missing feature? Let us know on YUILibrary.com." href="http://developer.yahoo.com/yui/articles/reportingbugs/">Bug Reports/Feature Requests</a></li><li class="item"><a title="YUI is free and open, offered under a BSD license." href="http://developer.yahoo.com/yui/license.html">YUI License</a></li><li class="item"><a title="Download and fork the YUI project on GitHub" href="http://github.com/yui">YUI on Github</a></li><li class="item"><a title="The Yahoo! User Interface Blog" href="http://yuiblog.com">YUI Blog (external)</a></li><li class="sect">YUI 3 Core - Examples</li><li class="item"><a title="YUI Global Object - Functional Examples" href="../../examples/yui/index.html">YUI Global Object</a></li><li class="item"><a title="Event - Functional Examples" href="../../examples/event/index.html">Event</a></li><li class="item"><a title="Node - Functional Examples" href="../../examples/node/index.html">Node</a></li><li class="sect">YUI 3 Component Infrastructure - Examples</li><li class="item"><a title="Attribute - Functional Examples" href="../../examples/attribute/index.html">Attribute</a></li><li class="item"><a title="Plugin - Functional Examples" href="../../examples/plugin/index.html">Plugin</a></li><li class="item"><a title="Widget - Functional Examples" href="../../examples/widget/index.html">Widget</a></li><li class="sect">YUI 3 Utilities - Examples</li><li class="item"><a title="Animation - Functional Examples" href="../../examples/anim/index.html">Animation</a></li><li class="item"><a title="AsyncQueue - Functional Examples" href="../../examples/async-queue/index.html">AsyncQueue</a></li><li class="item"><a title="Browser History - Functional Examples" href="../../examples/history/index.html">Browser History</a></li><li class="item"><a title="Cache - Functional Examples" href="../../examples/cache/index.html">Cache</a></li><li class="item"><a title="Cookie - Functional Examples" href="../../examples/cookie/index.html">Cookie</a></li><li class="item"><a title="DataSchema - Functional Examples" href="../../examples/dataschema/index.html">DataSchema <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="DataSource - Functional Examples" href="../../examples/datasource/index.html">DataSource <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="DataType - Functional Examples" href="../../examples/datatype/index.html">DataType <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="Drag &amp; Drop - Functional Examples" href="../../examples/dd/index.html">Drag &amp; Drop</a></li><li class="item"><a title="Get - Functional Examples" href="../../examples/get/index.html">Get</a></li><li class="item"><a title="ImageLoader - Functional Examples" href="../../examples/imageloader/index.html">ImageLoader</a></li><li class="item"><a title="Internationalization - Functional Examples" href="../../examples/intl/index.html">Internationalization <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="IO - Functional Examples" href="../../examples/io/index.html">IO</a></li><li class="item"><a title="JSON (JavaScript Object Notation) - Functional Examples" href="../../examples/json/index.html">JSON</a></li><li class="item"><a title="Stylesheet - Functional Examples" href="../../examples/stylesheet/index.html">Stylesheet</a></li><li class="sect">YUI 3 Widgets - Examples</li><li class="item"><a title="Overlay - Functional Examples" href="../../examples/overlay/index.html">Overlay <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="Slider - Functional Examples" href="../../examples/slider/index.html">Slider <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="Tabview - Functional Examples" href="../../examples/tabview/index.html">Tabview <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="sect">YUI 3 Node Plugins - Examples</li><li class="item"><a title="FocusManager Node Plugin - Functional Examples" href="../../examples/node-focusmanager/index.html">FocusManager Node Plugin <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="MenuNav Node Plugin - Functional Examples" href="../../examples/node-menunav/index.html">MenuNav Node Plugin <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="sect">YUI 3 CSS - Examples</li><li class="item"><a title="YUI CSS Reset - Functional Examples" href="../../examples/cssreset/index.html">CSS Reset</a></li><li class="item"><a title="YUI Fonts - Functional Examples" href="../../examples/cssfonts/index.html">CSS Fonts</a></li><li class="item"><a title="YUI Base - Functional Examples" href="../../examples/cssbase/index.html">CSS Base</a></li><li class="sect">YUI 3 Developer Tools - Examples</li><li class="item"><a title="Console - Functional Examples" href="../../examples/console/index.html">Console <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="Console Filters Plugin- Functional Examples" href="../../examples/console-filters/index.html">Plugin.ConsoleFilters <img alt='beta' src='http://l.yimg.com/a/i/not/beta_1.gif'></a></li><li class="item"><a title="Profiler - Functional Examples" href="../../examples/profiler/index.html">Profiler</a></li><li class="selected "><a title="Test - Functional Examples" href="../../examples/test/index.html">Test</a></li><li class="sect">Other Useful YUI 3 Resources</li><li class="item"><a title="Answers to Frequently Asked Questions about the YUI Library" href="http://developer.yahoo.com/yui/articles/faq/">YUI FAQ (external)</a></li><li class="item"><a title="Yahoo!'s philosophy of Graded Browser Support" href="http://developer.yahoo.com/yui/articles/gbs/">Graded Browser Support (external)</a></li><li class="item"><a title="Videos and podcasts from the YUI Team and from the Yahoo! frontend engineering community." href="http://developer.yahoo.com/yui/theater/">YUI Theater (external)</a></li></ul>
</div>
</div>
	</div><!--closes bd-->

	<div id="ft">
        <p class="first">Copyright &copy; 2010 Yahoo! Inc. All rights reserved.</p>
        <p><a href="http://privacy.yahoo.com/privacy/us/devel/index.html">Privacy Policy</a> - 
            <a href="http://docs.yahoo.com/info/terms/">Terms of Service</a> - 
            <a href="http://docs.yahoo.com/info/copyright/copyright.html">Copyright Policy</a> - 
            <a href="http://careers.yahoo.com/">Job Openings</a></p>
	</div>
</div>
<script language="javascript"> 
var yuiConfig = {};
</script>
<script src="../../assets/syntax.js"></script>
<script src="../../assets/dpSyntaxHighlighter.js"></script>
<script language="javascript"> 
dp.SyntaxHighlighter.HighlightAll('code'); 
</script>
</body>
</html>
